home *** CD-ROM | disk | FTP | other *** search
/ Greenhouse Effect Detection Expriment / NASA Greenhouse Effect Detection Expriment 1992 - Disc 2.iso / software / dos / cdf22pc / src / lib / cdfget.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-28  |  24.2 KB  |  922 lines
  1. /******************************************************************************
  2. *
  3. *  NSSDC/CDF                       CDF 'get' operations.
  4. *
  5. *  Version 1.0, 29-Feb-92, ST Systems (STX)
  6. *
  7. *  Modification history:
  8. *
  9. *   V1.0  29-Feb-92, J Love    Original version (was part of `cdflib.c').
  10. *
  11. ******************************************************************************/
  12.  
  13. #include "cdflib.h"
  14.  
  15. /******************************************************************************
  16. * CDFget.
  17. ******************************************************************************/
  18.  
  19. CDFstatus CDFget (ap, item, fnc)
  20. va_list *ap;
  21. long item;
  22. long *fnc;
  23. {
  24. CDFstatus Pstatus = CDF_OK;
  25. CDFstatus Tstatus;
  26.  
  27. switch (item) {
  28.   case CDF_NUMDIMS_: {
  29.     long *numDims;
  30.     numDims = va_arg (*ap, long *);
  31.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  32.     *numDims = _CURcdf->GDR.NumDims;
  33.     break;
  34.   }
  35.   case CDF_DIMSIZES_: {
  36.     long *dimsize;
  37.     long i;
  38.     dimsize = va_arg (*ap, long *);
  39.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  40.     for (i = 0; i < _CURcdf->GDR.NumDims; i++)
  41.        dimsize[i] = _CURcdf->GDR.DimSizes[i];
  42.     break;
  43.   }
  44.   case CDF_ENCODING_: {
  45.     long *encoding;
  46.     encoding = va_arg (*ap, long *);
  47.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  48.     *encoding = _CURcdf->CDR.Encoding;
  49.     break;
  50.   }
  51.   case CDF_MAJORITY_: {
  52.     long *majority;
  53.     majority = va_arg (*ap, long *);
  54.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  55.     if (bitset(_CURcdf->CDR.Flags,CDF_MAJORITY_BIT))
  56.       *majority = ROW_MAJOR;
  57.     else
  58.       *majority = COL_MAJOR;
  59.     break;
  60.   }
  61.   case CDF_FORMAT_: {
  62.     long *format;
  63.     format = va_arg (*ap, long *);
  64.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  65.     if (bitset(_CURcdf->CDR.Flags,CDF_FORMAT_BIT))
  66.       *format = SINGLE_FILE;
  67.     else
  68.       *format = MULTI_FILE;
  69.     break;
  70.   }
  71.   case CDF_COPYRIGHT_: {
  72.     char *copyRight;
  73.     copyRight = va_arg (*ap,  char *);
  74.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  75.     strcpy (copyRight, _CURcdf->CDR.copyright);
  76.     break;
  77.   }
  78.   case LIB_COPYRIGHT_: {
  79.     char *copyRight;
  80.     copyRight = va_arg (*ap,  char *);
  81.     strcpy (copyRight, _CDF_CopyRight);
  82.     break;
  83.   }
  84.   case CDF_NUMVARS_: {
  85.     long *numvars;
  86.     numvars = va_arg (*ap, long *);
  87.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  88.     *numvars = _CURcdf->GDR.NumVar;
  89.     break;
  90.   }
  91.   case CDF_NUMATTRS_: {
  92.     long *numattr;
  93.     numattr = va_arg (*ap, long *);
  94.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  95.     *numattr = _CURcdf->GDR.NumAttr;
  96.     break;
  97.   }
  98.   case CDF_MAXREC_: {
  99.     long *maxRec;
  100.     maxRec = va_arg (*ap, long *);
  101.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  102.     *maxRec = _CURcdf->GDR.MaxRec;
  103.     break;
  104.   }
  105.   case CDF_VERSION_: {
  106.     long *version;
  107.     version = va_arg (*ap, long *);
  108.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  109.     *version = _CURcdf->CDR.Version;
  110.     break;
  111.   }
  112.   case CDF_RELEASE_: {
  113.     long *release;
  114.     release = va_arg (*ap, long *);
  115.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  116.     *release = _CURcdf->CDR.Release;
  117.     break;
  118.   }
  119.   case CDF_INCREMENT_: {
  120.     long *increment;
  121.     increment = va_arg (*ap, long *);
  122.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  123.     *increment = _CURcdf->CDR.Increment;
  124.     break;
  125.   }
  126.   case LIB_VERSION_: {
  127.     long *version;
  128.     version = va_arg (*ap, long *);
  129.     *version = CDF_LIBRARY_VERSION;
  130.     break;
  131.   }
  132.   case LIB_RELEASE_: {
  133.     long *release;
  134.     release = va_arg (*ap, long *);
  135.     *release = CDF_LIBRARY_RELEASE;
  136.     break;
  137.   }
  138.   case LIB_INCREMENT_: {
  139.     long *increment;
  140.     increment = va_arg (*ap, long *);
  141.     *increment = CDF_LIBRARY_INCREMENT;
  142.     break;
  143.   }
  144.   case LIB_subINCREMENT_: {
  145.     char *subincrement;
  146.     subincrement = va_arg (*ap, char *);
  147.     *subincrement = CDF_LIBRARY_subINCREMENT;
  148.     break;
  149.   }
  150.   case VAR_NAME_: {
  151.     char *name;
  152.     name = va_arg (*ap,  char *);
  153.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  154.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  155.     strcpy (name, _CURcdf->CURvar->VDR.Name);
  156.     break;
  157.   }
  158.   case VAR_DATATYPE_: {
  159.     long *datatype;
  160.     datatype = va_arg (*ap, long *);
  161.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  162.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  163.     *datatype = _CURcdf->CURvar->VDR.DataType;
  164.     break;
  165.   }
  166.   case VAR_NUMELEMS_: {
  167.     long *numElements;
  168.     numElements = va_arg (*ap, long *);
  169.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  170.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  171.     *numElements = _CURcdf->CURvar->VDR.NumElem;
  172.     break;
  173.   }
  174.   case VAR_RECVARY_: {
  175.     long *recvary;
  176.     recvary = va_arg (*ap, long *);
  177.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  178.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  179.     if (bitset(_CURcdf->CURvar->VDR.Flags,VAR_RECVARY_BIT))
  180.       *recvary = VARY;
  181.     else
  182.       *recvary = NOVARY;
  183.     break;
  184.   }
  185.   case VAR_DIMVARYS_: {
  186.     long *dimVarys;
  187.     long i;
  188.     dimVarys = va_arg (*ap, long *);
  189.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  190.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  191.     for (i = 0; i < _CURcdf->GDR.NumDims; i++)
  192.        dimVarys[i] = _CURcdf->CURvar->VDR.DimVarys[i];
  193.     break;
  194.   }
  195.   case VAR_MAXREC_: {
  196.     long *varMaxRec;
  197.     varMaxRec = va_arg (*ap, long *);
  198.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  199.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  200.     *varMaxRec = _CURcdf->CURvar->VDR.MaxRec;
  201.     break;
  202.   }
  203.   case VAR_NUMBER_: {
  204.     char *name;
  205.     long *varnum;
  206.     struct varSTRUCT *Var;
  207.  
  208.     name = va_arg (*ap, char *);     /* no truncation of name if too long */
  209.     varnum = va_arg (*ap,  long *);
  210.  
  211.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  212.  
  213.     Var = _CURcdf->varHead;
  214.     while (Var != NULL) {
  215.       if (strcmpITB(Var->VDR.Name,name) == 0) break;
  216.       Var = Var->varNext;
  217.     }
  218.  
  219.     if (Var == NULL)
  220.       return NO_SUCH_VAR;
  221.     else
  222.       *varnum = Var->VDR.Num;
  223.  
  224.     break;
  225.   }
  226.   case VAR_DATA_: {
  227.     long indicesOffset;       /* offset (bytes) into record */
  228.     long recOffset;       /* offset (bytes) to start of record */
  229.     long offset;          /* offset (bytes) to value */
  230.     long phyRecNum, i;
  231.     long N;
  232.     char *value;
  233.     struct varSTRUCT *Var;
  234.  
  235.     value = va_arg (*ap, char *);
  236.  
  237.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  238.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  239.  
  240.     Var = _CURcdf->CURvar;
  241.  
  242.     if (Var->status == VAR_CLOSED) {
  243.       Tstatus = OpenVar (_CURcdf, Var);
  244.       STATUSdisp (Tstatus, Pstatus);
  245.     }
  246.  
  247.     Var->accessed_at = _CDFpseudo_clock++;
  248.  
  249. #if FULL_ERROR_CHECKING
  250.     if (_CURcdf->GDR.MaxRec < 0) return NO_RECORDS_EXIST;
  251.     if (_CURcdf->recnum > _CURcdf->GDR.MaxRec) return BAD_REC_NUM;
  252. #endif
  253.  
  254.     /* Compute physical record number */
  255.  
  256.     if (bitclr(Var->VDR.Flags,VAR_RECVARY_BIT))
  257.       phyRecNum = 0;
  258.     else
  259.       phyRecNum = _CURcdf->recnum;
  260.  
  261.     if (phyRecNum > Var->VDR.MaxRec) {
  262.       if (bitset(Var->VDR.Flags,VAR_FILLVALUE_BIT))
  263.     memmove (value, Var->VDR.FillValue, Var->NvalueBytes);
  264.       else {
  265.     /*** (NumElem will be 1 except for CDF_(U)CHAR) ***/
  266.     for (i = 0; i < Var->VDR.NumElem; i++)
  267.       memmove (value + i*_CDFelemSizes[Var->VDR.DataType],
  268.     _CDFdefaultFillValues[Var->VDR.DataType],
  269.     _CDFelemSizes[Var->VDR.DataType]);
  270.       }
  271.       STATUSdisp (VIRTUAL_RECORD_DATA, Pstatus);
  272.     }
  273.     else {
  274.       if (bitclr(_CURcdf->CDR.Flags,CDF_FORMAT_BIT))
  275.     recOffset = phyRecNum * Var->NphyRecBytes;
  276.       else
  277.     SINGLErecOffsetB (Var, phyRecNum, recOffset);
  278.  
  279.       INDICESoffsetB (_CURcdf->GDR.NumDims, Var, _CURcdf->indices,
  280.               indicesOffset);
  281.       offset = recOffset + indicesOffset;
  282.  
  283.       Seek (Var->fp, offset, SEEK_SET);
  284.       N = getbytes (Var->NvalueBytes, value, Var->fp);
  285.       if (N != Var->NvalueBytes) return VAR_READ_ERROR;
  286.  
  287.       DecodeBuffer (_CURcdf->CDR.Encoding,
  288.       Var->VDR.DataType,
  289.       Var->VDR.NumElem, value);
  290.     }
  291.     break;
  292.   }
  293.   case VAR_HYPERDATA_: {
  294.     long i;
  295.     char *buffer;
  296.     struct varSTRUCT *Var;
  297.     long Nvalues, Nbytes;
  298.  
  299.     buffer = va_arg (*ap, char *);
  300.  
  301.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  302.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  303.  
  304.     Var = _CURcdf->CURvar;
  305.  
  306.     if (Var->status == VAR_CLOSED) {
  307.       Tstatus = OpenVar (_CURcdf, Var);
  308.       STATUSdisp (Tstatus, Pstatus);
  309.     }
  310.  
  311.     Var->accessed_at = _CDFpseudo_clock++;
  312.  
  313. #if FULL_ERROR_CHECKING
  314.     if (_CURcdf->recnum +
  315.     ((_CURcdf->reccount - 1) *
  316.      _CURcdf->recinterval) > _CURcdf->GDR.MaxRec) return BAD_REC_NUM;
  317.  
  318.     for (i = 0; i < _CURcdf->GDR.NumDims; i++)
  319.        if (_CURcdf->indices[i] +
  320.        ((_CURcdf->counts[i] - 1) *
  321.         _CURcdf->intervals[i]) >= _CURcdf->GDR.DimSizes[i]) return
  322.                                  BAD_DIM_INDEX;
  323.  
  324. #if defined(__MSDOS__)
  325.     Nvalues = _CURcdf->reccount;
  326.     for (i = 0; i < _CURcdf->GDR.NumDims; i++) Nvalues *= _CURcdf->counts[i];
  327.     Nbytes = Nvalues * Var->VDR.NumElem * _CDFelemSizes[Var->VDR.DataType];
  328.     if (Nbytes > (long) 65535) return IBM_PC_OVERFLOW;
  329. #endif
  330. #endif
  331.  
  332.     if (bitset(_CURcdf->CDR.Flags,CDF_MAJORITY_BIT))
  333.       Tstatus = HyperAccess (Var, buffer, TRUE, TRUE);
  334.     else
  335.       Tstatus = HyperAccess (Var, buffer, FALSE, TRUE);
  336.     STATUSdisp (Tstatus, Pstatus);
  337.  
  338.     break;
  339.   }
  340.   case VAR_SEQDATA_: {
  341.     struct varSTRUCT *Var;
  342.     void *value;
  343.     long N;
  344.     long recOffset;
  345.     long offset;
  346.     long recN;  /* record number value is in */
  347.  
  348.     value = va_arg (*ap, char *);
  349.  
  350.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  351.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  352.  
  353.     Var = _CURcdf->CURvar;
  354.  
  355.     if (Var->status == VAR_CLOSED) {
  356.       Tstatus = OpenVar (_CURcdf, Var);
  357.       STATUSdisp (Tstatus, Pstatus);
  358.     }
  359.  
  360.     Var->accessed_at = _CDFpseudo_clock++;
  361.  
  362.     recN = Var->seqValueOffset / Var->NphyRecValues;
  363.     if (recN > Var->VDR.MaxRec)
  364.       return END_OF_VAR;
  365.     else {
  366.       if (bitclr(_CURcdf->CDR.Flags,CDF_FORMAT_BIT))
  367.     offset = Var->seqValueOffset * Var->NvalueBytes;
  368.       else {
  369.     SINGLErecOffsetB (Var, recN, recOffset);
  370.     offset = recOffset + (Var->seqValueOffset % Var->NphyRecValues) *
  371.                                  Var->NvalueBytes;
  372.       }
  373.  
  374.       Seek (Var->fp, offset, SEEK_SET);
  375.  
  376.       N = getbytes (Var->NvalueBytes, value, Var->fp);
  377.       if (N != Var->NvalueBytes) return VAR_READ_ERROR;
  378.  
  379.       DecodeBuffer (_CURcdf->CDR.Encoding, Var->VDR.DataType,
  380.       Var->VDR.NumElem, value);
  381.  
  382.       Var->seqValueOffset++;       /* increment to next value */
  383.     }
  384.  
  385.     break;
  386.   }
  387.   case VAR_FILLVALUE_: {
  388.     void *fillValue;
  389.     fillValue = va_arg (*ap, void *);
  390.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  391.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  392.     if (bitclr(_CURcdf->CURvar->VDR.Flags,VAR_FILLVALUE_BIT)) {
  393.       STATUSdisp (NO_FILLVALUE_SPECIFIED, Pstatus);
  394.     }
  395.     else
  396.       memmove (fillValue, _CURcdf->CURvar->VDR.FillValue,
  397.     _CURcdf->CURvar->NvalueBytes);
  398.     break;
  399.   }
  400.   case VAR_EXTENDRECS_: {
  401.     long *NextendRecs;
  402.     NextendRecs = va_arg (*ap, long *);
  403.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  404.     if (_CURcdf->CURvar == NULL) return NO_VAR_SELECTED;
  405.     *NextendRecs = _CURcdf->CURvar->VDR.NextendRecs;
  406.     break;
  407.   }
  408.   case ATTR_SCOPE_: {
  409.     long *scope;
  410.     scope = va_arg (*ap, long *);
  411.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  412.     if (_CURcdf->CURattr == NULL) return NO_ATTR_SELECTED;
  413.     *scope = _CURcdf->CURattr->ADR.Scope;
  414.     break;
  415.   }
  416.   case ATTR_NAME_: {
  417.     char *attrname;
  418.     attrname = va_arg (*ap,  char *);
  419.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  420.     if (_CURcdf->CURattr == NULL) return NO_ATTR_SELECTED;
  421.     strcpy (attrname, _CURcdf->CURattr->ADR.Name);
  422.     break;
  423.   }
  424.   case ATTR_NUMBER_: {
  425.     char *name;
  426.     long *attrnum;
  427.     struct attrSTRUCT *Attr;
  428.  
  429.     name = va_arg (*ap, char *);       /* no truncation of name if too long */
  430.     attrnum = va_arg (*ap,  long *);
  431.  
  432.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  433.  
  434.     Attr = _CURcdf->attrHead;
  435.     while (Attr != NULL) {
  436.       if (strcmpITB(name,Attr->ADR.Name) == 0) break;
  437.       Attr = Attr->attrNext;
  438.     }
  439.  
  440.     if (Attr == NULL)
  441.       return NO_SUCH_ATTR;
  442.     else
  443.       *attrnum = Attr->ADR.Num;
  444.  
  445.     break;
  446.   }
  447.   case ATTR_MAXENTRY_: {
  448.     long *maxEntry;
  449.     maxEntry = va_arg (*ap, long *);
  450.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  451.     if (_CURcdf->CURattr == NULL) return NO_ATTR_SELECTED;
  452.     *maxEntry = _CURcdf->CURattr->ADR.MaxEntry;
  453.     break;
  454.   }
  455.   case ATTR_NUMENTRIES_: {
  456.     long *numEntries;
  457.     numEntries = va_arg (*ap, long *);
  458.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  459.     if (_CURcdf->CURattr == NULL) return NO_ATTR_SELECTED;
  460.     *numEntries = _CURcdf->CURattr->ADR.NumEntries;
  461.     break;
  462.   }
  463.   case ENTRY_DATATYPE_: {
  464.     long *datatype;
  465.     datatype = va_arg (*ap, long *);
  466.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  467.     if (_CURcdf->CURentryNum == RESERVED_ENTRYNUM) return NO_ENTRY_SELECTED;
  468.     if (_CURcdf->CURattr == NULL) return NO_ATTR_SELECTED;
  469.     if (_CURcdf->CURentry == NULL) return NO_SUCH_ENTRY;
  470.     *datatype = _CURcdf->CURentry->AEDR.DataType;
  471.     break;
  472.   }
  473.   case ENTRY_NUMELEMS_: {
  474.     long *numelem;
  475.     numelem = va_arg (*ap, long *);
  476.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  477.     if (_CURcdf->CURentryNum == RESERVED_ENTRYNUM) return NO_ENTRY_SELECTED;
  478.     if (_CURcdf->CURattr == NULL) return NO_ATTR_SELECTED;
  479.     if (_CURcdf->CURentry == NULL) return NO_SUCH_ENTRY;
  480.     *numelem = _CURcdf->CURentry->AEDR.NumElem;
  481.     break;
  482.   }
  483.   case ENTRY_DATA_: {
  484.     void *value;
  485.     long numbytes;
  486.     value = va_arg (*ap, void *);
  487.  
  488.     if (_CURcdf == NULL) return NO_CDF_SELECTED;
  489.     if (_CURcdf->CURentryNum == RESERVED_ENTRYNUM) return NO_ENTRY_SELECTED;
  490.     if (_CURcdf->CURattr == NULL) return NO_ATTR_SELECTED;
  491.     if (_CURcdf->CURentry == NULL) return NO_SUCH_ENTRY;
  492.  
  493.     numbytes = _CURcdf->CURentry->AEDR.NumElem *
  494.     _CDFelemSizes[_CURcdf->CURentry->AEDR.DataType];
  495.     memmove (value, _CURcdf->CURentry->AEDR.Value, numbytes);
  496.  
  497.     break;
  498.   }
  499.   case STATUS_TEXT_: {
  500.     char *textPtr;
  501.     textPtr = va_arg (*ap, char *);
  502.  
  503. #if INCLUDE_STATUS_TEXT
  504.     switch (_CURstatus) {
  505.        case VIRTUAL_RECORD_DATA:
  506.        strcpy (textPtr, "VIRTUAL_RECORD_DATA: One or more \
  507. of the records are virtual (never written to the CDF).");
  508.        break;
  509.  
  510.        case READ_ONLY_ACCESS:
  511.        strcpy (textPtr, "READ_ONLY_ACCESS: Read-only \
  512. access is allowed on the CDF (no writing or deleting).");
  513.        break;
  514.  
  515.        case VERSION_1_CDF:
  516.        strcpy (textPtr, "VERSION_1_CDF: This is a Version \
  517. 1 CDF - some restrictions may apply.");
  518.        break;
  519.  
  520.        case CDF_OK:
  521.        strcpy (textPtr, "CDF_OK: Function completed \
  522. successfully.");
  523.        break;
  524.  
  525.        case ATTR_NAME_TRUNC:
  526.        strcpy (textPtr, "ATTR_NAME_TRUNC: Attribute name \
  527. truncated to maximum allowed number of characters.");
  528.        break;
  529.  
  530.        case CDF_NAME_TRUNC:
  531.        strcpy (textPtr, "CDF_NAME_TRUNC: CDF path name \
  532. truncated to maximum allowed number of characters.");
  533.        break;
  534.  
  535.        case VAR_NAME_TRUNC:
  536.        strcpy (textPtr, "VAR_NAME_TRUNC: Variable name \
  537. truncated to maximum allowed number of characters.");
  538.        break;
  539.  
  540.        case CDF_INCOMPATIBLE:
  541.        strcpy (textPtr, "CDF_INCOMPATIBLE: Certain \
  542. operations on Version 2 CDFs are incompatible with the OBSOLETE interface.");
  543.        break;
  544.  
  545.        case VAR_ALREADY_CLOSED:
  546.        strcpy (textPtr, "VAR_ALREADY_CLOSED: The specified \
  547. variable is already closed.");
  548.        break;
  549.  
  550.        case SINGLE_FILE_FORMAT:
  551.        strcpy (textPtr, "SINGLE_FILE_FORMAT: The specified \
  552. operation is not applicable to CDFs with the SINGLE file format.");
  553.        break;
  554.  
  555.        case NO_FILLVALUE_SPECIFIED:
  556.        strcpy (textPtr, "NO_FILLVALUE_SPECIFIED: A fill \
  557. value has not yet been specified.");
  558.        break;
  559.  
  560.        case NO_VARS_IN_CDF:
  561.        strcpy (textPtr, "NO_VARS_IN_CDF: This CDF contains \
  562. no variables.");
  563.        break;
  564.  
  565.        case ATTR_EXISTS:
  566.        strcpy (textPtr, "ATTR_EXISTS: Named attribute \
  567. already exists - cannot create it.");
  568.        break;
  569.  
  570.        case BAD_CDF_ID:
  571.        strcpy (textPtr, "BAD_CDF_ID: CDF identifier is \
  572. unknown or invalid.");
  573.        break;
  574.  
  575.        case BAD_DATA_TYPE:
  576.        strcpy (textPtr, "BAD_DATA_TYPE: Unknown data type \
  577. specified.");
  578.        break;
  579.  
  580.        case BAD_DIM_SIZE:
  581.        strcpy (textPtr, "BAD_DIM_SIZE: One or more \
  582. dimension size specified as zero or less.");
  583.        break;
  584.  
  585.        case BAD_DIM_INDEX:
  586.        strcpy (textPtr, "BAD_DIM_INDEX: One or more \
  587. dimension index is out of range.");
  588.        break;
  589.  
  590.        case BAD_ENCODING:
  591.        strcpy (textPtr, "BAD_ENCODING: Unknown or \
  592. unsupported data encoding.");
  593.        break;
  594.  
  595.        case BAD_MAJORITY:
  596.        strcpy (textPtr, "BAD_MAJORITY: Unknown majority \
  597. specified.");
  598.        break;
  599.  
  600.        case BAD_NUM_DIMS:
  601.        strcpy (textPtr, "BAD_NUM_DIMS: The number of \
  602. dimensions specified is out of the allowed range.");
  603.        break;
  604.  
  605.        case BAD_REC_NUM:
  606.        strcpy (textPtr, "BAD_REC_NUM: Record number is \
  607. out of range.");
  608.        break;
  609.  
  610.        case BAD_SCOPE:
  611.        strcpy (textPtr, "BAD_SCOPE: Unrecognized scope for \
  612. attribute creation.");
  613.        break;
  614.  
  615.        case BAD_NUM_ELEMS:
  616.        strcpy (textPtr, "BAD_NUM_ELEMS: The number of \
  617. elements of the data type is illegal.");
  618.        break;
  619.  
  620.        case CDF_CREATE_ERROR:
  621.        strcpy (textPtr, "CDF_CREATE_ERROR: Cannot create \
  622. CDF specified - error from file system.");
  623.        break;
  624.  
  625.        case CDF_OPEN_ERROR:
  626.        strcpy (textPtr, "CDF_OPEN_ERROR: Cannot open \
  627. CDF specified - error from file system.");
  628.        break;
  629.  
  630.        case CDF_EXISTS:
  631.        strcpy (textPtr, "CDF_EXISTS: The CDF named already \
  632. exists - cannot create it.");
  633.        break;
  634.  
  635.        case BAD_FORMAT:
  636.        strcpy (textPtr, "BAD_FORMAT: Unknown CDF format \
  637. specified.");
  638.        break;
  639.  
  640.        case VAX_ENCODING_UNSUPPORTED:
  641.        strcpy (textPtr, "VAX_ENCODING_UNSUPPORTED: VAX \
  642. encoding is not supported on the host machine.");
  643.        break;
  644.  
  645.        case SUN_ENCODING_UNSUPPORTED:
  646.        strcpy (textPtr, "SUN_ENCODING_UNSUPPORTED: Sun \
  647. encoding is not supported on the host machine.");
  648.        break;
  649.  
  650.        case NO_SUCH_ATTR:
  651.        strcpy (textPtr, "NO_SUCH_ATTR: Attribute not found \
  652. in this CDF.");
  653.        break;
  654.  
  655.        case NO_SUCH_CDF:
  656.        strcpy (textPtr, "NO_SUCH_CDF: The specified CDF does not exist.");
  657.        break;
  658.  
  659.        case NO_SUCH_ENTRY:
  660.        strcpy (textPtr, "NO_SUCH_ENTRY: No such entry for \
  661. specified attribute.");
  662.        break;
  663.  
  664.        case NO_SUCH_VAR:
  665.        strcpy (textPtr, "NO_SUCH_VAR: Variable not found \
  666. in this CDF.");
  667.        break;
  668.  
  669.        case VAR_READ_ERROR:
  670.        strcpy (textPtr, "VAR_READ_ERROR: Failed to read \
  671. variable as requested (file read error).");
  672.        break;
  673.  
  674.        case VAR_WRITE_ERROR:
  675.        strcpy (textPtr, "VAR_WRITE_ERROR: Failed to write \
  676. variable as requested (file write error).");
  677.        break;
  678.  
  679.        case TOO_MANY_CDFS:
  680.        strcpy (textPtr, "TOO_MANY_CDFS: A limited number \
  681. of CDFs may be opened at once.");
  682.        break;
  683.  
  684.        case TOO_MANY_VARS:
  685.        strcpy (textPtr, "TOO_MANY_VARS: A CDF may contain \
  686. only a limited number of variables.");
  687.        break;
  688.  
  689.        case VAR_EXISTS:
  690.        strcpy (textPtr, "VAR_EXISTS: Named variable \
  691. already exists - cannot create it.");
  692.        break;
  693.  
  694.        case BAD_MALLOC:
  695.        strcpy (textPtr, "BAD_MALLOC: Unable to allocate \
  696. dynamic memory - system limit reached.");
  697.        break;
  698.  
  699.        case NOT_A_CDF:
  700.        strcpy (textPtr, "NOT_A_CDF: Named CDF is corrupted \
  701. or not actually a CDF.");
  702.        break;
  703.  
  704.        case CORRUPTED_V2_CDF:
  705.        strcpy (textPtr, "CORRUPTED_V2_CDF: This version 2 \
  706. CDF is corrupted.");
  707.        break;
  708.  
  709.        case VAR_OPEN_ERROR:
  710.        strcpy (textPtr, "VAR_OPEN_ERROR: An error occurred \
  711. while opening variable file.");
  712.        break;
  713.  
  714.        case BAD_INITIAL_RECS:
  715.        strcpy (textPtr, "BAD_INITIAL_RECS: An illegal \
  716. number of records to initially write has been specified.");
  717.        break;
  718.  
  719.        case BAD_EXTEND_RECS:
  720.        strcpy (textPtr, "BAD_EXTEND_RECS: An illegal \
  721. number of extend records has been specified.");
  722.        break;
  723.  
  724.        case END_OF_VAR:
  725.        strcpy (textPtr, "END_OF_VAR: The value offset (for \
  726. sequential access) is at the end of the variable.");
  727.        break;
  728.  
  729.        case MIPSEB_ENCODING_UNSUPPORTED:
  730.        strcpy (textPtr, "MIPSEB_ENCODING_UNSUPPORTED: \
  731. MIPSEB encoding is not supported on the host machine.");
  732.        break;
  733.  
  734.        case BAD_CDFSTATUS:
  735.        strcpy (textPtr, "BAD_CDFSTATUS: Unknown CDFstatus \
  736. value received.");
  737.        break;
  738.  
  739.        case NO_WRITE_ACCESS:
  740.        strcpy (textPtr, "NO_WRITE_ACCESS: Writing is not \
  741. allowed (read-only access).");
  742.        break;
  743.  
  744.        case NO_DELETE_ACCESS:
  745.        strcpy (textPtr, "NO_DELETE_ACCESS: Deleting is not \
  746. allowed (read-only access).");
  747.        break;
  748.  
  749.        case BAD_REC_COUNT:
  750.        strcpy (textPtr, "BAD_REC_COUNT: Illegal record \
  751. count specified.");
  752.        break;
  753.  
  754.        case BAD_REC_INTERVAL:
  755.        strcpy (textPtr, "BAD_REC_INTERVAL: Illegal record \
  756. interval specified.");
  757.        break;
  758.  
  759.        case BAD_DIM_COUNT:
  760.        strcpy (textPtr, "BAD_DIM_COUNT: Illegal dimension \
  761. count specified.");
  762.        break;
  763.  
  764.        case BAD_DIM_INTERVAL:
  765.        strcpy (textPtr, "BAD_DIM_INTERVAL: Illegal \
  766. dimension interval specified.");
  767.        break;
  768.  
  769.        case BAD_VAR_NUM:
  770.        strcpy (textPtr, "BAD_VAR_NUM: Illegal variable \
  771. number specified.");
  772.        break;
  773.  
  774.        case BAD_ATTR_NUM:
  775.        strcpy (textPtr, "BAD_ATTR_NUM: Illegal attribute \
  776. number specified.");
  777.        break;
  778.  
  779.        case BAD_ENTRY_NUM:
  780.        strcpy (textPtr, "BAD_ENTRY_NUM: Illegal attribute \
  781. entry number specified.");
  782.        break;
  783.  
  784.        case BAD_ATTR_NAME:
  785.        strcpy (textPtr, "BAD_ATTR_NAME: Illegal attribute \
  786. name specified.");
  787.        break;
  788.  
  789.        case BAD_VAR_NAME:
  790.        strcpy (textPtr, "BAD_VAR_NAME: Illegal variable \
  791. name specified.");
  792.        break;
  793.  
  794.        case NO_ATTR_SELECTED:
  795.        strcpy (textPtr, "NO_ATTR_SELECTED: An attribute \
  796. has not yet been selected.");
  797.        break;
  798.  
  799.        case NO_ENTRY_SELECTED:
  800.        strcpy (textPtr, "NO_ENTRY_SELECTED: An attribute \
  801. entry has not yet been selected.");
  802.        break;
  803.  
  804.        case NO_VAR_SELECTED:
  805.        strcpy (textPtr, "NO_VAR_SELECTED: A variable has \
  806. not yet been selected.");
  807.        break;
  808.  
  809.        case BAD_CDF_NAME:
  810.        strcpy (textPtr, "BAD_CDF_NAME: Illegal CDF name \
  811. specified.");
  812.        break;
  813.  
  814.        case MIPSEL_ENCODING_UNSUPPORTED:
  815.        strcpy (textPtr, "MIPSEL_ENCODING_UNSUPPORTED: \
  816. MIPSEL encoding is not supported on the host machine.");
  817.        break;
  818.  
  819.        case CANNOT_CHANGE:
  820.        strcpy (textPtr, "CANNOT_CHANGE: Because of \
  821. dependencies on the value, it cannot be changed.");
  822.        break;
  823.  
  824.        case NO_STATUS_SELECTED:
  825.        strcpy (textPtr, "NO_STATUS_SELECTED: A CDF status \
  826. code has not yet been selected.");
  827.        break;
  828.  
  829.        case NO_CDF_SELECTED:
  830.        strcpy (textPtr, "NO_CDF_SELECTED: A CDF \
  831. has not yet been selected.");
  832.        break;
  833.  
  834.        case NO_RECORDS_EXIST:
  835.        strcpy (textPtr, "NO_RECORDS_EXIST: No records \
  836. exist in the CDF.");
  837.        break;
  838.  
  839.        case CDF_CLOSE_ERROR:
  840.        strcpy (textPtr, "CDF_CLOSE_ERROR: Error detected \
  841. while trying to close CDF.");
  842.        break;
  843.  
  844.        case VAR_CLOSE_ERROR:
  845.        strcpy (textPtr, "VAR_CLOSE_ERROR: Error detected \
  846. while trying to close variable file.");
  847.        break;
  848.  
  849.        case BAD_FNC_OR_ITEM:
  850.        strcpy (textPtr, "BAD_FNC_OR_ITEM: The specified \
  851. function or item is illegal.");
  852.        break;
  853.  
  854.        case CORRUPTED_V1_CDF:
  855.        strcpy (textPtr, "CORRUPTED_V1_CDF: This Version 1 \
  856. CDF is corrupted.");
  857.        break;
  858.  
  859.        case ILLEGAL_ON_V1_CDF:
  860.        strcpy (textPtr, "ILLEGAL_ON_V1_CDF: The specified \
  861. operation is not allowed on Version 1 CDFs.");
  862.        break;
  863.  
  864.        case CDH_OPEN_ERROR:
  865.        strcpy (textPtr, "CDH_OPEN_ERROR: An error occurred \
  866. while opening the .CDH file (V1 CDF).");
  867.        break;
  868.  
  869.        case CDH_CLOSE_ERROR:
  870.        strcpy (textPtr, "CDH_CLOSE_ERROR: An error \
  871. occurred while closing the .CDH file (V1 CDF).");
  872.        break;
  873.  
  874.        case V1_CDF_UNSUPPORTED:
  875.        strcpy (textPtr, "V1_CDF_UNSUPPORTED: Version 1 \
  876. CDFs are not supported on the host machine.");
  877.        break;
  878.  
  879.        case IBMPC_ENCODING_UNSUPPORTED:
  880.        strcpy (textPtr, "IBMPC_ENCODING_UNSUPPORTED: \
  881. IBMPC encoding is not supported on the host machine.");
  882.        break;
  883.  
  884.        case IBM_PC_OVERFLOW:
  885.        strcpy (textPtr, "IBM_PC_OVERFLOW: \
  886. An operation involving more than 64Kb of contiguous memory was attempted.");
  887.        break;
  888.  
  889.        case IBMRS_ENCODING_UNSUPPORTED:
  890.        strcpy (textPtr, "IBMRS_ENCODING_UNSUPPORTED: \
  891. IBMRS encoding is not supported on the host machine.");
  892.        break;
  893.  
  894.        case HP_ENCODING_UNSUPPORTED:
  895.        strcpy (textPtr, "HP_ENCODING_UNSUPPORTED: \
  896. HP encoding is not supported on the host machine.");
  897.        break;
  898.  
  899.        case VAR_CREATE_ERROR:
  900.        strcpy (textPtr, "VAR_CREATE_ERROR: \
  901. An error occurred while creating a variable file (multi-file CDF).");
  902.        break;
  903.  
  904.        default:
  905.        strcpy (textPtr, "Text not found (unknown \
  906. CDFstatus).");
  907.        return BAD_CDFSTATUS;
  908.     }
  909. #else
  910.     strcpy (textPtr, "Explanation text not available (%ld).", _CURstatus);
  911. #endif
  912.     break;
  913.   }
  914.  
  915.   default: {
  916.     *fnc = item;
  917.     break;
  918.   }
  919. }
  920. return Pstatus;
  921. }
  922.